1. Field of the Invention
The present invention relates to an object-oriented computer software technology and associated program development tools that support software application program developers and end users by generating a user interface for the application program, pursuant to the developer""s or end user""s specifications.
A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to any facsimile or reproduction of the material as it appears in the patent document or the patent disclosure, or as the material appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
2. Description of the Related Art
One of the most important aspects of a modern computing system is the interface between the human user and the machine. The earliest type of interface was text based; a user communicated with the machine by typing text characters on a keyboard and the machine communicated with the user by displaying text characters on a printer or display screen. More recently, graphic user interfaces have become popular where the machine communicates with a user by displaying graphics, including text and pictures, on a display screen and the user communicates with the machine both by typing in textual commands and by manipulating the displayed pictures with a pointing device, such as a mouse.
Many modern computer systems operate with a graphic user interface called a window environment. In a typical window environment, the graphical display portrayed on the display screen is arranged to resemble the surface of an electronic xe2x80x9cdesktopxe2x80x9d and each application program running on the computer is represented as one or more electronic xe2x80x9cpaper sheetsxe2x80x9d displayed in rectangular regions of the screen called xe2x80x9cwindowsxe2x80x9d.
Each window region generally displays information generated by the associated application program and there may be several window regions simultaneously present on the desktop, each representing information generated by one or more application programs. A program presents information to the user through each window by drawing or xe2x80x9cpaintingxe2x80x9d images, graphics or text within the window region. The user, in turn, communicates with the application by xe2x80x9cpointing atxe2x80x9d objects in the window region with a cursor which is controlled by a pointing device and manipulating or moving the objects and also by typing information using the keyboard. When objects within the window are selected or manipulated, the underlying application program is informed, via the window system, that the control has been manipulated by the user. The window regions may also be moved around on the display screen and changed in size and appearance so that the user can arrange the desktop in a convenient manner.
In current systems, the window environment described above is part of the computer operating system. The application program typically makes use of operating system functions by sending out series of task commands to the operating system, which then performs a requested task. For example, the application program may request that the operating system play an audible tone, display a warning window, printer dialog box, or other graphical information to the user in order to obtain the user""s input to determine the next appropriate action. As computer systems have become more complex and more capable of multitasking, operating systems have evolved to include a central window manager that interfaces with each application program to ensure that each program""s display data is separated from other displays, that the display is properly refreshed when windows are moved or resized by the user, and that user interaction with the display to provide input to the application program is properly communicated back to the application. The window manager also typically handles the high level facilities (buttons, sliders, list boxes and other controls) that application programs commonly use to provide a complete user interface.
Of course, these complexities behind displays and display management are invisible to computer users, who have come to expect simple, intuitive interfaces to even the most sophisticated computer programs. High-order computer languages, compilers, and operating systems have evolved to enable and provide implicit support to program developers for the creation and execution of even very sophisticated application programs. However, the same cannot be said when it comes to the design and development of a program""s user interface. Indeed, historically, the user interaction space has never been considered to be a fundamental part of a computer program. User interface activities are often referred to as input and output, meaning that somehow data is extracted out of the program and displayed to the user and that somehow data is received from the user and put into the program. This xe2x80x9csomehowxe2x80x9d is accomplished by program developers writing explicit program code to get the data out of the program, format and display the data, receive input data from the user and put it back in to the program. Indeed, in addition to writing code to get data into and out of the program, the programmer must also write explicit code to create the look and feel that the programmer wants the user to experience when running and interacting with the program. The programmer must also ensure that user interface code properly interacts with the underlying program code so that they remain synchronized and the overall integrity of the system is maintained.
Due to the complexity of current graphical user interface environments, programmers often utilize specialized libraries of user interface code to reduce the amount of code they must write when providing support for the user interaction space. For example, Microsoft Corporation provides a class library for software developers known as the MICROSOFT FOUNDATION CLASS (xe2x80x9cMFCxe2x80x9d) Library, which contains object classes implemented in C++ that are useful for programmers in developing user interfaces for object-oriented applications programs running on the MICROSOFT WINDOWS operating system. Nevertheless, even with the availability of class libraries such as MFC, application program developers must still spend an inordinate amount of development time dealing with interface implementation details, such as determining what type of control might be appropriate for certain input (e.g., button, menu bar, drop-down menu, dialog window, etc.); what color the image should be, how it should be labeled, where it should appear on the screen, etc. The user interface code for a new application program typically comprises a melange of library code, modified library code, and xe2x80x9cfrom scratchxe2x80x9d code cobbled together by the programmer to create the desired appearance and operation of the interface between the program and the user. Having to provide explicit code to support the user interaction space has the following disadvantages:
Bigger Programsxe2x80x94Adding explicit code to support the user interaction space greatly increases the size of the original program.
Increased Complexityxe2x80x94The complexity of a computer program is directly related to the amount of code contained within it. Consequently, supporting the user interaction space with explicit code results in a more complex program.
Compromised Integrityxe2x80x94Errors in the explicit code added to a computer program could result in data being erroneously input or displayed. This compromises the integrity of the entire system.
Direct Relationship Between Code and User Interfacexe2x80x94Having to explicitly support the user interaction space means that for every variation in the user interface, a corresponding amount of code has to be created to support it.
Taken together, these problems explain why creating the user interface of a computer program often accounts for a significant (and indeed, unreasonable) portion of the development effort. Program developers should be primarily concerned with the task at handxe2x80x94designing and developing a computer program that solves a real-world problem, or provides a useful functionxe2x80x94and should not be mired in the implementation details of the user interface. From a program developer""s standpoint, a computer program that is capable of generating its own user interface would represent an enormous improvement in the art.
The present invention, called OUTERFACING, fills this need by providing implicit support for the user interaction space in an object-oriented system. Programmers practicing the present invention in an object-oriented environment take advantage of the natural structural properties of objects and object systems and provide individual objects with the inherent ability to represent themselves in the user interaction space and to interact with the user. These representations, referred to in this disclosure as xe2x80x9cviews,xe2x80x9d are a collection of user interface controls that represent the data members and functions defined in a particular object class. Programs that incorporate the present invention can have state of the art user interfaces without the requirement for underlying explicit user interface code. Instead, the user interface is created by the program itself, which directly visualizes and interacts with the objects that exist within the program. In addition, the present invention provides an interactive xe2x80x9cView Editorxe2x80x9d which enables program users to interactively create and save views of objects.
The present invention comprises a method and apparatus that automatically creates the user interface in an object-oriented software program. The present invention includes a visual object base class that comprises functions that support the creation and management of views, one or more instrumented object classes that are subclasses of the visual object base class and from which instrumented objects are created, and a Visualization Engine. Each instrumented object class further comprises a block of functions that define one or more of the class members to be visual elements that are capable of being represented in the user interface environment. The Visualization Engine further comprises an Object Manager, a Visualization Manager, a Synchronization Manager, and a Repository Manager. The Visualization Engine interacts with the visual object base class and each instrumented object created from the instrumented object classes, and, using a Global Class Table, a Class Descriptor, a View Descriptor, and an Object Descriptor, creates views of the instrumented objects and maintains synchronicity between the views and the underlying object members by generating the appropriate commands to the operating system. Each view created by the Visualization Engine comprises a representation of one or more of said visual elements of each said instrumented object that is meaningful to a human user.
The present invention also comprises a View Editor that enables real-time interactive modification of object views. The present invention also allows instrumented object classes to be derived from other instrumented object classes, and when this occurs, views associated with the parent instrumented object class are inherited by the derived instrumented object class.